#include "smart_home_ui.h"
#include "shutdown_screen.h"
#include "myfont.h"
#include "led_control.h"
#include "light_control.h"
#include "music_player.h"
#include "weather.h"
#include "device_state_manager.h"  // 添加设备状态管理器头文件
#include "call_screen.h"
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include "lvgl/lvgl.h"
#include "ac_control.h"

// 移除了互斥锁机制，简化界面管理

// 屏幕管理相关全局变量
static lv_obj_t *home_screen_instance = NULL;
static bool home_screen_valid = false;

// MQTT云平台集成相关全局变量
static lv_timer_t *cloud_sync_timer = NULL;
static mqtt_status_t current_cloud_status = MQTT_DISCONNECTED;

// 函数前向声明
static void cleanup_smart_home_ui_components(void);
static void delayed_weather_switch_cb(lv_timer_t *timer);
static void cloud_sync_timer_cb(lv_timer_t *timer);
static void set_temperature_value(int celsius);
static void set_humidity_value(int percent);
void cloud_light_control_callback(int light_index, bool state);  // 云平台灯光控制回调函数
void cloud_ac_control_callback(const char* action, int value);   // 云平台空调控制回调函数
void cloud_music_control_callback(const char* action, int value); // 云平台音乐控制回调函数

// 全局变量定义
lv_obj_t *time_label;
lv_obj_t *date_label;
lv_timer_t *timer_update;

lv_obj_t *light1_switch;
lv_obj_t *light2_switch;
lv_obj_t *ac_switch;
lv_obj_t *curtain_slider;
lv_obj_t *curtain_label;
lv_obj_t *curtain_image;  // 窗帘动图显示对象
lv_obj_t *curtain_auto_btn;
static lv_timer_t *curtain_anim_timer = NULL;  // 窗帘动画定时器
static bool curtain_is_opening = false;  // 窗帘动画状态标志
static int curtain_anim_frame_count = 0;  // 窗帘动画帧计数器
static lv_timer_t *curtain_auto_timer = NULL;  // 窗帘自动移动定时器
static int curtain_target_position = 0;  // 目标位置
static int curtain_move_step = 2;  // 每次移动的步长
lv_obj_t *temperature_value_label;
lv_obj_t *humidity_value_label;
lv_obj_t *smoke_bar;
lv_obj_t *smoke_label;
lv_obj_t *message_content;

// 右拉菜单相关变量
lv_obj_t *sidebar_menu;
lv_obj_t *home_item;
lv_obj_t *weather_item;
lv_obj_t *devices_item;
lv_obj_t *music_item;
lv_obj_t *settings_item;
lv_obj_t *shutdown_item;
lv_obj_t *sidebar_mask; // 遮罩层
lv_obj_t *menu_btn; // 菜单按钮指针
int sidebar_x; // 菜单位置
bool sidebar_open = false;

// 全局空调状态
bool global_ac_power_state = false;

// 全局窗帘状态
int global_curtain_position = 0;  // 窗帘位置 0-100
bool global_curtain_auto = false; // 窗帘自动控制状态

// 全局灯光状态
bool global_light1_state = false;  // 灯光1状态
bool global_light2_state = false;  // 灯光2状态
bool global_light3_state = false;  // 灯光3状态
bool global_light4_state = false;  // 灯光4状态

// 全局烟雾浓度状态
int global_smoke_density = 15;  // 烟雾浓度 0-100，默认15

// ADC相关变量
static int adc_fd = -1;  // ADC设备文件描述符
static lv_timer_t *adc_timer = NULL;  // ADC读取定时器
static const char *adc_device_path = "/sys/bus/iio/devices/iio:device0/in_voltage6_raw";
static int adc_min_value = 10;   // ADC最小值（实际测得）
static int adc_max_value = 1024; // ADC最大值（实际测得）

// 缓存上次应用的数值以减少重复刷新（用于标签更新）
static int last_temperature_value = INT_MIN;
static int last_humidity_value = INT_MIN;

// 获取当前显示的温度值（从界面标签直接读取）
int get_current_temperature(void) {
    if(temperature_value_label && lv_obj_is_valid(temperature_value_label)) {
        const char* text = lv_label_get_text(temperature_value_label);
        if(text) {
            // 如果显示未初始化状态，返回特殊值表示未知
            if(strstr(text, "--") != NULL) {
                return -999;  // 特殊值表示温度未知
            }
            // 解析温度值，格式类似 "25°C"
            int temperature = 0;
            sscanf(text, "%d", &temperature);
            return temperature;
        }
    }
    // 如果无法从界面读取，返回特殊值表示未知
    return -999;
}

// 获取当前显示的湿度值（从界面标签直接读取）
int get_current_humidity(void) {
    if(humidity_value_label && lv_obj_is_valid(humidity_value_label)) {
        const char* text = lv_label_get_text(humidity_value_label);
        if(text) {
            // 解析湿度值，格式类似 "60%"
            int humidity = 0;
            sscanf(text, "%d", &humidity);
            return humidity;
        }
    }
    // 如果无法从界面读取，返回特殊值表示未知
    return -999;
}

/*====================
 * 用户设置保存和加载机制
 *==================*/

#define USER_SETTINGS_FILE "./tmp/smart_home_settings.txt"

// 保存用户设置到文件
void save_user_settings(void) {
    // 确保 tmp 目录存在
    struct stat st = {0};
    if (stat("./tmp", &st) == -1) {
        if (mkdir("./tmp", 0755) == -1) {
            printf("警告: 无法创建 tmp 目录: %s\n", strerror(errno));
            return;
        }
        printf("创建了 tmp 目录\n");
    }
    
    FILE *file = fopen(USER_SETTINGS_FILE, "w");
    if (!file) {
        printf("警告: 无法保存用户设置到 %s: %s\n", USER_SETTINGS_FILE, strerror(errno));
        return;
    }
    
    // 保存空调设置
    fprintf(file, "ac_power=%d\n", global_ac_power_state ? 1 : 0);
    fprintf(file, "ac_temp=%d\n", get_ac_current_temp());
    fprintf(file, "ac_mode=%d\n", get_ac_current_mode());
    
    // 保存灯光设置
    fprintf(file, "light1=%d\n", global_light1_state ? 1 : 0);
    fprintf(file, "light2=%d\n", global_light2_state ? 1 : 0);
    fprintf(file, "light3=%d\n", global_light3_state ? 1 : 0);
    fprintf(file, "light4=%d\n", global_light4_state ? 1 : 0);
    
    // 保存窗帘设置
    fprintf(file, "curtain_pos=%d\n", global_curtain_position);
    fprintf(file, "curtain_auto=%d\n", global_curtain_auto ? 1 : 0);
    
    // 温湿度为固定显示值，不需要保存
    
    fclose(file);
    printf("用户设置已保存\n");
}

// 从文件加载用户设置
void load_user_settings(void) {
    FILE *file = fopen(USER_SETTINGS_FILE, "r");
    if (!file) {
        printf("首次运行或设置文件不存在: %s\n", USER_SETTINGS_FILE);
        return;
    }
    
    char line[128];
    int value;
    
    while (fgets(line, sizeof(line), file)) {
        if (sscanf(line, "ac_power=%d", &value) == 1) {
            global_ac_power_state = (value == 1);
            printf("从用户设置恢复空调电源状态: %s\n", global_ac_power_state ? "开启" : "关闭");
            // 恢复空调电源状态
        }
        else if (sscanf(line, "ac_temp=%d", &value) == 1) {
            // 调用空调模块的设置函数恢复温度
            set_ac_temp_from_settings(value);
            printf("恢复空调温度: %d°C\n", value);
        }
        // 删除重复的灯3和灯4设置加载代码
        
        else if (sscanf(line, "ac_mode=%d", &value) == 1) {
            // 调用空调模块的设置函数恢复模式
            set_ac_mode_from_settings(value);
            printf("恢复空调模式: %d\n", value);
        }
        else if (sscanf(line, "light1=%d", &value) == 1) {
            global_light1_state = (value == 1);
            // 恢复灯光1状态
        }
        else if (sscanf(line, "light2=%d", &value) == 1) {
            global_light2_state = (value == 1);
            // 恢复灯光2状态
        }
        else if (sscanf(line, "light3=%d", &value) == 1) {
            global_light3_state = (value == 1);
            // 恢复厨房灯状态
        }
        else if (sscanf(line, "light4=%d", &value) == 1) {
            global_light4_state = (value == 1);
            // 恢复阳台灯状态
        }
        else if (sscanf(line, "curtain_pos=%d", &value) == 1) {
            global_curtain_position = value;
            printf("恢复窗帘位置: %d%%\n", value);
        }
        else if (sscanf(line, "curtain_auto=%d", &value) == 1) {
            global_curtain_auto = (value == 1);
            printf("恢复窗帘自动模式: %s\n", value ? "开启" : "关闭");
        }
        // 温湿度为固定显示值，不需要恢复
    }
    
    fclose(file);
    printf("用户设置加载完成\n");
}

// 从设置恢复空调温度（调用空调模块的内部函数）
void set_ac_temp_from_settings(int temperature) {
    // 这个函数需要在ac_control.c中实现
    // 我们通过外部声明来调用
    extern void restore_ac_temperature(int temperature);
    restore_ac_temperature(temperature);
}

// 从设置恢复空调模式（调用空调模块的内部函数）
void set_ac_mode_from_settings(int mode) {
    // 这个函数需要在ac_control.c中实现
    // 我们通过外部声明来调用
    extern void restore_ac_mode(int mode);
    restore_ac_mode(mode);
}

// 动画执行回调适配函数
static void anim_set_x_cb(void *obj, int32_t value) {
    lv_obj_set_x((lv_obj_t *)obj, value);
}

// 透明度动画执行回调函数
static void anim_set_opa_cb(void *obj, int32_t value) {
    lv_obj_set_style_opa((lv_obj_t *)obj, (lv_opa_t)value, LV_PART_MAIN);
}

// 隐藏遮罩的定时器回调函数
static void hide_mask_timer_cb(lv_timer_t *t) {
    lv_obj_add_flag(sidebar_mask, LV_OBJ_FLAG_HIDDEN);
    lv_timer_del(t);  // 删除定时器
}

// 延迟切换到天气页面的回调函数
static void delayed_weather_switch_cb(lv_timer_t *timer) {
    cleanup_smart_home_ui();
    create_weather_screen();
    lv_timer_del(timer);  // 删除定时器
}

// 延迟切换到音乐播放器的回调函数
static void delayed_music_switch_cb(lv_timer_t *timer) {
    cleanup_smart_home_ui();
    create_music_player_screen();
    lv_timer_del(timer);  // 删除定时器
}

// 延迟切换到设备控制的回调函数
static void delayed_devices_switch_cb(lv_timer_t *timer) {
    cleanup_smart_home_ui();
    create_ac_control_screen();
    lv_timer_del(timer);  // 删除定时器
}

// 窗帘动画定时器回调函数
static void curtain_anim_timer_cb(lv_timer_t *t) {
    const int animation_duration = 8;  // 动画持续8帧，约800ms
    
    // 首先检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        if(curtain_anim_timer) {
            lv_timer_del(t);
            curtain_anim_timer = NULL;
            curtain_anim_frame_count = 0;
        }
        return;
    }
    
    if(curtain_image == NULL || !lv_obj_is_valid(curtain_image)) {
        if(curtain_anim_timer) {
            lv_timer_del(t);
            curtain_anim_timer = NULL;
            curtain_anim_frame_count = 0;
        }
        return;
    }
    
    curtain_anim_frame_count++;
    
    // 创建淡入淡出效果
    if(curtain_anim_frame_count <= animation_duration / 2) {
        // 前半段：淡出当前图片
        lv_opa_t opa = LV_OPA_COVER - (curtain_anim_frame_count * LV_OPA_COVER / (animation_duration / 2));
        lv_obj_set_style_img_opa(curtain_image, opa, LV_PART_MAIN);
    } else if(curtain_anim_frame_count == animation_duration / 2 + 1) {
        // 中间点：切换图片，确保使用当前的窗帘状态
        bool current_should_be_open = (global_curtain_position >= 50);
        if(current_should_be_open) {
            lv_img_set_src(curtain_image, &open_cur);
        } else {
            lv_img_set_src(curtain_image, &close_cur);
        }
    } else if(curtain_anim_frame_count <= animation_duration) {
        // 后半段：淡入新图片
        int fade_frame = curtain_anim_frame_count - (animation_duration / 2 + 1);
        lv_opa_t opa = (fade_frame * LV_OPA_COVER / (animation_duration / 2));
        lv_obj_set_style_img_opa(curtain_image, opa, LV_PART_MAIN);
    }
    
    // 动画结束
    if(curtain_anim_frame_count >= animation_duration) {
        lv_obj_set_style_img_opa(curtain_image, LV_OPA_COVER, LV_PART_MAIN);
        
        // 最终状态检查：确保显示的图片与当前滑块值匹配
        bool final_should_be_open = (global_curtain_position >= 50);
        if(final_should_be_open) {
            lv_img_set_src(curtain_image, &open_cur);
        } else {
            lv_img_set_src(curtain_image, &close_cur);
        }
        
        lv_timer_del(t);
        curtain_anim_timer = NULL;
        curtain_anim_frame_count = 0;  // 重置帧计数器
    }
}

// 重置时间更新函数中的静态变量
static void reset_time_cache(void) {
    // 这里我们需要访问静态变量，但由于作用域限制，我们通过强制更新来解决
    // 下次调用 update_time_task 时，force_update 会强制更新所有内容
}

// 更新时间的回调函数（简化版本）
static void update_time_task(lv_timer_t *timer) {
    // timer为NULL时是手动调用（强制更新），这是合法的
    
    // 首先检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        return; // 首页无效时不更新时间
    }
    
    static time_t last_update_s = 0;
    static char last_date_str[32] = "";
    static char last_time_str[32] = "";
    
    time_t now;
    time(&now);
    
    // 当timer为NULL时（手动调用），强制更新一次
    bool force_update = (timer == NULL);
    
    // 仅在秒有变化时更新，避免重复重绘
    if(!force_update && now == last_update_s) return;
    last_update_s = now;
    
    // 安全检查：确保标签存在且有效
    if(date_label == NULL || time_label == NULL) {
        return;
    }
    
    if(!lv_obj_is_valid(date_label) || !lv_obj_is_valid(time_label)) {
        return;
    }
    
    time_t raw_time;
    struct tm *time_info;
    char date_str[32];
    char time_str[32];
    
    raw_time = now;
    time_info = localtime(&raw_time);
    
    // 分别格式化日期和时间
    strftime(date_str, sizeof(date_str), "%Y-%m-%d", time_info);
    strftime(time_str, sizeof(time_str), "%H:%M:%S", time_info);
    
    // 设置日期和时间标签文本 - 添加额外的安全检查
    if(force_update || strcmp(last_date_str, date_str) != 0) {
        // 再次检查对象有效性（防止在执行过程中被删除）
        if(date_label && lv_obj_is_valid(date_label)) {
            lv_label_set_text(date_label, date_str);
            strcpy(last_date_str, date_str);
        } else {
            printf("警告: date_label在更新时变为无效\n");
        }
    }
    if(force_update || strcmp(last_time_str, time_str) != 0) {
        // 再次检查对象有效性（防止在执行过程中被删除）
        if(time_label && lv_obj_is_valid(time_label)) {
            lv_label_set_text(time_label, time_str);
            strcpy(last_time_str, time_str);
        } else {
            printf("警告: time_label在更新时变为无效\n");
        }
    }
}

// 全局变量定义
lv_obj_t *light1_label;
lv_obj_t *light2_label;
lv_obj_t *light3_label;
lv_obj_t *light4_label;
lv_obj_t *light3_switch;
lv_obj_t *light4_switch;
lv_obj_t *ac_label;

// 灯光开关回调
static void light_switch_event_cb(lv_event_t *e) {
    lv_obj_t *obj = lv_event_get_target(e);
    bool state = lv_obj_has_state(obj, LV_STATE_CHECKED);

    // 分别处理灯光1-4
    if(obj == light1_switch) {
        // 控制实际的LED1 (GPIO120)
        if(led_set_state(LED1_GPIO, state) == 0) {
            // 保存灯光1状态到全局变量
            global_light1_state = state;
            if(light1_label) lv_label_set_text(light1_label, state ? "灯光1: 开" : "灯光1: 关");
            // 同步到灯光控制界面
            set_light_state(0, state);  // LED1对应索引0
        } else {
            // LED控制失败，恢复开关状态
            if(state) {
                lv_obj_clear_state(light1_switch, LV_STATE_CHECKED);
            } else {
                lv_obj_add_state(light1_switch, LV_STATE_CHECKED);
            }
            if(light1_label) lv_label_set_text(light1_label, "灯光1: 错误");
        }
    } else if(obj == light2_switch) {
        // 控制实际的LED2 (GPIO121)
        if(led_set_state(LED2_GPIO, state) == 0) {
            // 保存灯光2状态到全局变量
            global_light2_state = state;
            if(light2_label) lv_label_set_text(light2_label, state ? "灯光2: 开" : "灯光2: 关");
            // 同步到灯光控制界面
            set_light_state(1, state);  // LED2对应索引1
        } else {
            // LED控制失败，恢复开关状态
            if(state) {
                lv_obj_clear_state(light2_switch, LV_STATE_CHECKED);
            } else {
                lv_obj_add_state(light2_switch, LV_STATE_CHECKED);
            }
            if(light2_label) lv_label_set_text(light2_label, "灯光2: 错误");
        }
    } else if(obj == light3_switch) {
        // 控制实际的LED3 (GPIO122)
        if(led_set_state(LED3_GPIO, state) == 0) {
            // 保存灯光3状态到全局变量
            global_light3_state = state;
            if(light3_label) lv_label_set_text(light3_label, state ? "灯光3: 开" : "灯光3: 关");
            // 同步到灯光控制界面
            set_light_state(2, state);  // LED3对应索引2
        } else {
            // LED控制失败，恢复开关状态
            if(state) {
                lv_obj_clear_state(light3_switch, LV_STATE_CHECKED);
            } else {
                lv_obj_add_state(light3_switch, LV_STATE_CHECKED);
            }
            if(light3_label) lv_label_set_text(light3_label, "灯光3: 错误");
        }
    } else if(obj == light4_switch) {
        // 控制实际的LED4 (GPIO123)
        if(led_set_state(LED4_GPIO, state) == 0) {
            // 保存灯光4状态到全局变量
            global_light4_state = state;
            if(light4_label) lv_label_set_text(light4_label, state ? "灯光4: 开" : "灯光4: 关");
            // 同步到灯光控制界面
            set_light_state(3, state);  // LED4对应索引3
        } else {
            // LED控制失败，恢复开关状态
            if(state) {
                lv_obj_clear_state(light4_switch, LV_STATE_CHECKED);
            } else {
                lv_obj_add_state(light4_switch, LV_STATE_CHECKED);
            }
            if(light4_label) lv_label_set_text(light4_label, "灯光4: 错误");
        }
    }
}

// 空调开关回调
static void ac_switch_event_cb(lv_event_t *e) {
    lv_obj_t *obj = lv_event_get_target(e);
    bool state = lv_obj_has_state(obj, LV_STATE_CHECKED);
    
    // 确保对象是我们关注的开关
    if(ac_switch == obj) {
        // 直接调用同步函数更新全局状态
        sync_ac_power_state(state);
    }
}

// 窗帘滑块回调
static void curtain_slider_event_cb(lv_event_t *e) {
    // 如果在自动模式下，不响应用户手动操作
    if(global_curtain_auto) {
        // 恢复到当前全局位置，防止用户拖动改变显示
        lv_obj_t *slider = lv_event_get_target(e);
        lv_slider_set_value(slider, global_curtain_position, LV_ANIM_OFF);
        return;
    }
    
    lv_obj_t *slider = lv_event_get_target(e);
    static int32_t last_value = -1;
    static uint32_t last_update_time = 0;  // 记录上次更新时间
    
    int32_t value = lv_slider_get_value(slider);
    if(value == last_value) return;
    last_value = value;
    
    // 获取当前时间，用于防抖动
    uint32_t current_time = lv_tick_get();
    
    char buf[32];
    snprintf(buf, sizeof(buf), "窗帘: %d%%", value);
    
    if(curtain_slider == slider) {
        // 保存窗帘位置到全局状态
        global_curtain_position = value;
        
        // 保存用户设置
        save_user_settings();
        
        if(curtain_label != NULL) {
            lv_label_set_text(curtain_label, buf);
        }
        
        // 更新窗帘动图显示（带动画效果）
        if(curtain_image != NULL) {
            bool should_be_open = (value >= 50);
            static bool last_state = false;  // 记录上次状态
            static bool first_call = true;   // 标记是否第一次调用
            
            // 第一次调用时，根据当前状态初始化last_state
            if(first_call) {
                last_state = should_be_open;
                first_call = false;
                // 确保图片显示正确
                if(should_be_open) {
                    lv_img_set_src(curtain_image, &open_cur);
                } else {
                    lv_img_set_src(curtain_image, &close_cur);
                }
                last_update_time = current_time;
                return;  // 第一次调用不播放动画
            }
            
            // 只有状态发生变化时才播放动画
            if(should_be_open != last_state) {
                curtain_is_opening = should_be_open;
                
                // 如果已有动画在进行，先停止
                if(curtain_anim_timer != NULL) {
                    lv_timer_del(curtain_anim_timer);
                    curtain_anim_timer = NULL;
                    curtain_anim_frame_count = 0;  // 重置帧计数器
                }
                
                // 如果用户快速滑动（时间间隔小于200ms），直接切换图片不播放动画
                if(current_time - last_update_time < 200) {
                    if(should_be_open) {
                        lv_img_set_src(curtain_image, &open_cur);
                    } else {
                        lv_img_set_src(curtain_image, &close_cur);
                    }
                    lv_obj_set_style_img_opa(curtain_image, LV_OPA_COVER, LV_PART_MAIN);
                } else {
                    // 启动新的动画
                    curtain_anim_frame_count = 0;  // 重置帧计数器
                    curtain_anim_timer = lv_timer_create(curtain_anim_timer_cb, 100, NULL);
                }
                
                last_state = should_be_open;
                last_update_time = current_time;
            }
        }
    }
}

// 窗帘自动控制按钮回调
static void curtain_auto_btn_event_cb(lv_event_t *e) {
    lv_obj_t *btn = lv_event_get_target(e);
    
    // 切换自动模式状态
    global_curtain_auto = !global_curtain_auto;
    
    // 更新按钮显示
    lv_obj_t *btn_label = lv_obj_get_child(btn, 0);
    if(global_curtain_auto) {
        lv_label_set_text(btn_label, "Auto: ON");
        lv_obj_set_style_bg_color(btn, lv_color_hex(0x27ae60), LV_PART_MAIN); // 绿色表示开启
        // 自动模式：滑块半透明，进度条变为灰色，并禁用交互
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_50, LV_PART_MAIN);
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_50, LV_PART_KNOB);
        lv_obj_set_style_bg_color(curtain_slider, lv_color_hex(0x7f8c8d), LV_PART_INDICATOR); // 灰色指示器
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_60, LV_PART_INDICATOR);
        // 在自动模式下禁用滑块交互（视觉上更明显）
        lv_obj_add_state(curtain_slider, LV_STATE_DISABLED);
    } else {
        lv_label_set_text(btn_label, "Auto: OFF");
        lv_obj_set_style_bg_color(btn, lv_color_hex(0x95a5a6), LV_PART_MAIN); // 灰色表示关闭
        // 手动模式：恢复正常显示，蓝色指示器
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_COVER, LV_PART_MAIN);
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_COVER, LV_PART_KNOB);
        lv_obj_set_style_bg_color(curtain_slider, lv_color_hex(0x3498db), LV_PART_INDICATOR); // 蓝色指示器
        lv_obj_set_style_bg_opa(curtain_slider, LV_OPA_COVER, LV_PART_INDICATOR);
        // 启用滑块交互
        lv_obj_clear_state(curtain_slider, LV_STATE_DISABLED);
    }
    

}

// 窗帘自动移动定时器回调
static void curtain_auto_move_timer_cb(lv_timer_t *timer) {
    // 首先检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        if(curtain_auto_timer) {
            lv_timer_del(curtain_auto_timer);
            curtain_auto_timer = NULL;
        }
        return;
    }
    
    if(curtain_slider == NULL || !lv_obj_is_valid(curtain_slider)) {
        if(curtain_auto_timer) {
            lv_timer_del(curtain_auto_timer);
            curtain_auto_timer = NULL;
        }
        return;
    }
    
    int current_pos = lv_slider_get_value(curtain_slider);
    
    // 计算移动方向和距离
    if(current_pos == curtain_target_position) {
        // 到达目标位置，停止定时器
        if(curtain_auto_timer) {
            lv_timer_del(curtain_auto_timer);
            curtain_auto_timer = NULL;
        }
        return;
    }
    
    // 计算下一步位置
    int next_pos;
    if(current_pos < curtain_target_position) {
        next_pos = current_pos + curtain_move_step;
        if(next_pos > curtain_target_position) {
            next_pos = curtain_target_position;
        }
    } else {
        next_pos = current_pos - curtain_move_step;
        if(next_pos < curtain_target_position) {
            next_pos = curtain_target_position;
        }
    }
    
    // 更新滑块位置
    lv_slider_set_value(curtain_slider, next_pos, LV_ANIM_OFF);
    global_curtain_position = next_pos;
    
    // 更新窗帘标签
    if(curtain_label != NULL) {
        char curtain_buf[32];
        snprintf(curtain_buf, sizeof(curtain_buf), "窗帘: %d%% (自动)", next_pos);
        lv_label_set_text(curtain_label, curtain_buf);
    }
    
    // 更新窗帘图片（当跨越50%阈值时）
    if(curtain_image != NULL) {
        static bool last_open_state = false;
        bool current_open_state = (next_pos >= 50);
        if(current_open_state != last_open_state) {
            if(current_open_state) {
                lv_img_set_src(curtain_image, &open_cur);
            } else {
                lv_img_set_src(curtain_image, &close_cur);
            }
            last_open_state = current_open_state;
        }
    }
}

// 菜单按钮点击回调声明
static void menu_btn_click_cb(lv_event_t *e);

// 注意：这些函数声明已移动到文件顶部

// ADC函数声明
static int start_adc_smoke_monitoring(void);
static void stop_adc_smoke_monitoring(void);




// 菜单选项点击回调
static void menu_item_click_cb(lv_event_t *e) {
    lv_obj_t *obj = lv_event_get_target(e);

    // 使用对象指针判断点击的是哪个菜单项，避免对按钮误用 lv_label_get_text 导致崩溃
    if(obj == home_item) {
        // 首页处理逻辑（留空）
    } else if(obj == weather_item) {
        // 进入天气页面 - 使用延迟执行避免在回调中删除当前屏幕
        printf("进入天气页面\n");
        // 使用定时器延迟执行，避免在事件回调中立即删除屏幕
        lv_timer_create(delayed_weather_switch_cb, 5, NULL);
        return;
    } else if(obj == devices_item) {
        // 进入设备 -> 空调控制界面 - 使用延迟执行避免卡顿
        printf("进入设备控制页面\n");
        lv_timer_create(delayed_devices_switch_cb, 5, NULL);
        return;
    } else if(obj == music_item) {
        // 进入音乐播放器界面 - 使用延迟执行避免卡顿
        printf("进入音乐播放器页面\n");
        lv_timer_create(delayed_music_switch_cb, 5, NULL);
        return;
    } else if(obj == settings_item) {
        // 进入呼叫页面
        printf("进入呼叫页面\n");
        create_call_screen();
    } else if(obj == shutdown_item) {
        // 关机处理 - 播放关机动画
        printf("启动关机序列\n");
        create_shutdown_screen();
        return;
    }
    
    // 点击后关闭菜单
    sidebar_open = false;
    lv_anim_t a;
    lv_anim_init(&a);
    lv_anim_set_var(&a, sidebar_menu);
    lv_anim_set_values(&a, 0, -240);  // 从当前位置移动到屏幕外
    lv_anim_set_time(&a, 300);
    lv_anim_set_exec_cb(&a, anim_set_x_cb);
    lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
    lv_anim_start(&a);
    sidebar_x = -240;
    
    // 菜单关闭时显示按钮
    lv_obj_clear_flag(menu_btn, LV_OBJ_FLAG_HIDDEN);
    // 恢复按钮原始样式
    lv_obj_set_style_bg_color(menu_btn, lv_color_hex(0x2c3e50), LV_PART_MAIN);  // 使用与背景协调的深色
    lv_obj_set_style_bg_opa(menu_btn, LV_OPA_70, LV_PART_MAIN);  // 保持透明度
    // 重新对齐按钮到左侧中部，确保紧贴左侧
    lv_obj_align(menu_btn, LV_ALIGN_LEFT_MID, 0, 0);
    // 确保按钮在最前面
    lv_obj_move_foreground(menu_btn);
    
    // 淡出并隐藏遮罩
    lv_anim_t mask_anim;
    lv_anim_init(&mask_anim);
    lv_anim_set_var(&mask_anim, sidebar_mask);
    lv_anim_set_values(&mask_anim, 100, 0);
    lv_anim_set_time(&mask_anim, 300);
    lv_anim_set_exec_cb(&mask_anim, anim_set_opa_cb);
    lv_anim_set_path_cb(&mask_anim, lv_anim_path_ease_in);
    lv_anim_start(&mask_anim);
    
    // 动画结束后隐藏遮罩
    lv_timer_create(hide_mask_timer_cb, 300, NULL);
}


// 创建菜单函数
static void create_sidebar_menu(lv_obj_t *parent_screen) {
    // 创建遮罩层
    sidebar_mask = lv_obj_create(parent_screen);
    lv_obj_set_size(sidebar_mask, lv_pct(100), lv_pct(100));
    lv_obj_set_style_bg_color(sidebar_mask, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(sidebar_mask, 0, LV_PART_MAIN);  // 初始透明
    lv_obj_add_flag(sidebar_mask, LV_OBJ_FLAG_HIDDEN);
    lv_obj_clear_flag(sidebar_mask, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_add_event_cb(sidebar_mask, menu_btn_click_cb, LV_EVENT_CLICKED, NULL);  // 点击遮罩关闭菜单

    // 创建菜单容器
    sidebar_menu = lv_obj_create(parent_screen);
    lv_obj_set_size(sidebar_menu, 240, lv_pct(100));
    lv_obj_set_x(sidebar_menu, -240);  // 初始位置在屏幕左侧外部
    lv_obj_set_style_bg_color(sidebar_menu, lv_color_hex(0x2c3e50), LV_PART_MAIN);
    lv_obj_set_style_border_width(sidebar_menu, 1, LV_PART_MAIN);
    lv_obj_set_style_border_color(sidebar_menu, lv_color_hex(0x34495e), LV_PART_MAIN);
    lv_obj_clear_flag(sidebar_menu, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_move_foreground(sidebar_menu);  // 确保菜单在遮罩上方
    
    // 创建菜单标题
    lv_obj_t *menu_title = lv_label_create(sidebar_menu);
    lv_obj_set_style_text_font(menu_title, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(menu_title, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(menu_title, "智能菜单");
    lv_obj_align(menu_title, LV_ALIGN_TOP_MID, 0, 20);
    
    // 创建菜单项
    static lv_style_t item_style;
    lv_style_init(&item_style);
    lv_style_set_pad_ver(&item_style, 15);
    lv_style_set_pad_left(&item_style, 20);
    lv_style_set_bg_color(&item_style, lv_color_hex(0x34495e));
    lv_style_set_text_font(&item_style, &lv_font_source_han_sans_bold_20);
    lv_style_set_text_color(&item_style, lv_color_hex(0xFFFFFF));
    
    // 首页
    home_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(home_item, lv_pct(100), 60);
    lv_obj_align(home_item, LV_ALIGN_TOP_MID, 0, 80);
    lv_obj_add_style(home_item, &item_style, 0);
    lv_obj_t *home_label = lv_label_create(home_item);
    lv_label_set_text(home_label, "首页");
    lv_obj_center(home_label);
    lv_obj_add_event_cb(home_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
    
    // 天气
    weather_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(weather_item, lv_pct(100), 60);
    lv_obj_align_to(weather_item, home_item, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_add_style(weather_item, &item_style, 0);
    lv_obj_t *weather_label = lv_label_create(weather_item);
    lv_label_set_text(weather_label, LV_SYMBOL_EYE_OPEN " 天气");
    lv_obj_center(weather_label);
    lv_obj_add_event_cb(weather_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
    
    // 设备
    devices_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(devices_item, lv_pct(100), 60);
    lv_obj_align_to(devices_item, weather_item, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_add_style(devices_item, &item_style, 0);
    lv_obj_t *devices_label = lv_label_create(devices_item);
    lv_label_set_text(devices_label, "设备");
    lv_obj_center(devices_label);
    lv_obj_add_event_cb(devices_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
    
    // 音乐
    music_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(music_item, lv_pct(100), 60);
    lv_obj_align_to(music_item, devices_item, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_add_style(music_item, &item_style, 0);
    lv_obj_t *music_label = lv_label_create(music_item);
    lv_label_set_text(music_label, LV_SYMBOL_AUDIO " 音乐");
    lv_obj_center(music_label);
    lv_obj_add_event_cb(music_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
    
    // 呼叫
    settings_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(settings_item, lv_pct(100), 60);
    lv_obj_align_to(settings_item, music_item, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_add_style(settings_item, &item_style, 0);
    lv_obj_t *settings_label = lv_label_create(settings_item);
    lv_label_set_text(settings_label, LV_SYMBOL_CALL " 呼叫");
    lv_obj_center(settings_label);
    lv_obj_add_event_cb(settings_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
    
    // 关机
    shutdown_item = lv_btn_create(sidebar_menu);
    lv_obj_set_size(shutdown_item, lv_pct(100), 60);
    lv_obj_align_to(shutdown_item, settings_item, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_add_style(shutdown_item, &item_style, 0);
    // 关机按钮使用红色背景
    lv_obj_set_style_bg_color(shutdown_item, lv_color_hex(0xe74c3c), LV_PART_MAIN);
    lv_obj_t *shutdown_label = lv_label_create(shutdown_item);
    lv_label_set_text(shutdown_label, LV_SYMBOL_POWER " 关机");
    lv_obj_center(shutdown_label);
    lv_obj_add_event_cb(shutdown_item, menu_item_click_cb, LV_EVENT_CLICKED, NULL);
}



// 菜单按钮点击回调
static void menu_btn_click_cb(lv_event_t *e) {
    // 安全检查：确保菜单对象仍然有效
    if(!sidebar_menu || !lv_obj_is_valid(sidebar_menu) || 
       !sidebar_mask || !lv_obj_is_valid(sidebar_mask) ||
       !menu_btn || !lv_obj_is_valid(menu_btn)) {
        printf("菜单对象无效，忽略点击事件\n");
        return;
    }
    
    // 动态获取屏幕宽度
    lv_coord_t menu_width = 240; // 菜单宽度

    if(!sidebar_open) {
        sidebar_open = true;
        lv_anim_t a;
        lv_anim_init(&a);
        lv_anim_set_var(&a, sidebar_menu);
        lv_anim_set_values(&a, -menu_width, 0);  // 从屏幕左侧外部移动到左侧边缘
        lv_anim_set_time(&a, 300);
        lv_anim_set_exec_cb(&a, anim_set_x_cb);
        lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
        lv_anim_start(&a);
        sidebar_x = 0;  // 更新菜单位置

        // 菜单打开时隐藏按钮
        lv_obj_add_flag(menu_btn, LV_OBJ_FLAG_HIDDEN);

        // 显示并淡入遮罩
        lv_obj_clear_flag(sidebar_mask, LV_OBJ_FLAG_HIDDEN);
        lv_anim_t mask_anim;
        lv_anim_init(&mask_anim);
        lv_anim_set_var(&mask_anim, sidebar_mask);
        lv_anim_set_values(&mask_anim, 0, 100);
        lv_anim_set_time(&mask_anim, 300);
        lv_anim_set_exec_cb(&mask_anim, anim_set_opa_cb);
        lv_anim_start(&mask_anim);
    } else {
        sidebar_open = false;
        lv_anim_t a;
        lv_anim_init(&a);
        lv_anim_set_var(&a, sidebar_menu);
        lv_anim_set_values(&a, 0, -menu_width);  // 从左侧边缘移动到屏幕左侧外部
        lv_anim_set_time(&a, 300);
        lv_anim_set_exec_cb(&a, anim_set_x_cb);
        lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
        lv_anim_start(&a);
        sidebar_x = -menu_width;  // 更新菜单位置

        // 菜单关闭时显示按钮
        lv_obj_clear_flag(menu_btn, LV_OBJ_FLAG_HIDDEN);
        // 恢复按钮原始样式
        lv_obj_set_style_bg_color(menu_btn, lv_color_hex(0x2c3e50), LV_PART_MAIN);  // 使用与背景协调的深色
        lv_obj_set_style_bg_opa(menu_btn, LV_OPA_70, LV_PART_MAIN);  // 保持透明度
        // 重新对齐按钮到左侧中部，确保紧贴左侧
        lv_obj_align(menu_btn, LV_ALIGN_LEFT_MID, 0, 0);
        // 确保按钮在最前面
        lv_obj_move_foreground(menu_btn);
        // 额外添加可见性保障
        lv_obj_clear_flag(menu_btn, LV_OBJ_FLAG_HIDDEN);

        // 淡出并隐藏遮罩
        lv_anim_t mask_anim;
        lv_anim_init(&mask_anim);
        lv_anim_set_var(&mask_anim, sidebar_mask);
        lv_anim_set_values(&mask_anim, 100, 0);
        lv_anim_set_time(&mask_anim, 300);
        lv_anim_set_exec_cb(&mask_anim, anim_set_opa_cb);
        lv_anim_set_path_cb(&mask_anim, lv_anim_path_ease_in);
        lv_anim_start(&mask_anim);
        
        // 添加动画结束回调，确保动画完成后再隐藏遮罩
        lv_anim_set_ready_cb(&mask_anim, NULL);  // 先不设置回调
        lv_anim_start(&mask_anim);
        
        // 使用定时器在动画结束后隐藏遮罩
        lv_timer_create(hide_mask_timer_cb, 300, NULL);
    }
}



// 移除了复杂的延迟删除机制，使用简化的直接删除

// 屏幕创建和管理函数

// 安全清理智能家居界面但保留屏幕对象
static void cleanup_smart_home_ui_components(void) {
    // 首先标记屏幕无效，阻止定时器回调中的UI更新
    home_screen_valid = false;
    
    // 注释掉ADC监测停止，让烟雾监控在后台持续运行，确保安全监控
    // stop_adc_smoke_monitoring();  // 保持ADC监测运行，确保烟雾警报在所有页面都有效
    
    // 清理定时器 - 添加安全检查
    if(timer_update) {
        lv_timer_del(timer_update);
        timer_update = NULL;
    }
    
    // 清理窗帘动画定时器 - 添加安全检查
    if(curtain_anim_timer) {
        lv_timer_del(curtain_anim_timer);
        curtain_anim_timer = NULL;
        curtain_anim_frame_count = 0;
    }
    
    // 清理窗帘自动移动定时器 - 添加安全检查
    if(curtain_auto_timer) {
        lv_timer_del(curtain_auto_timer);
        curtain_auto_timer = NULL;
    }
    
    // 给一个较长的延迟，确保所有定时器回调都有机会完成
    usleep(50000);  // 50毫秒延迟
}

// 创建智能家居界面实现
static void create_smart_home_ui_impl(void) {
    // 初始化LED控制
    led_init();
    
    // 创建新的智能家居屏幕
    home_screen_instance = lv_obj_create(NULL);
    if(!home_screen_instance) {
        return;
    }
    
    home_screen_valid = true;
    lv_obj_set_style_bg_color(home_screen_instance, lv_color_hex(0x2c3e50), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(home_screen_instance, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_clear_flag(home_screen_instance, LV_OBJ_FLAG_SCROLLABLE);
    
    // 使用延迟加载屏幕，让LVGL自动处理旧屏幕的清理
    lv_scr_load_anim(home_screen_instance, LV_SCR_LOAD_ANIM_NONE, 0, 0, false);
    
    // 全屏无效化 + 立即刷新
    lv_obj_invalidate(home_screen_instance);
    lv_refr_now(NULL);
    
// 创建顶部环境信息区域（不可滚动）
lv_obj_t *env_area = lv_obj_create(home_screen_instance);
if(!env_area) {
    return;
}
lv_obj_set_size(env_area, lv_pct(100), 120);
lv_obj_align(env_area, LV_ALIGN_TOP_MID, 0, 0);
lv_obj_set_style_bg_color(env_area, lv_color_hex(0x34495e), LV_PART_MAIN);
lv_obj_set_style_border_width(env_area, 0, LV_PART_MAIN);
lv_obj_clear_flag(env_area, LV_OBJ_FLAG_SCROLLABLE);

// 创建温度图标（使用新的图片资源）
lv_obj_t *temp_icon = lv_img_create(env_area);
lv_img_set_src(temp_icon, &temp);
lv_obj_set_size(temp_icon, 56, 56);  // 缩放到合适尺寸
lv_obj_align(temp_icon, LV_ALIGN_LEFT_MID, 30, 0);

// 外部温度数值标签（位于图标右侧）
temperature_value_label = lv_label_create(env_area);
// 使用支持"°"的字体
lv_obj_set_style_text_font(temperature_value_label, &lv_font_montserrat_20, LV_PART_MAIN);
lv_obj_set_style_text_color(temperature_value_label, lv_color_hex(0xecf0f1), LV_PART_MAIN);
lv_label_set_text(temperature_value_label, "25°C");  // 固定显示25°C
lv_obj_align_to(temperature_value_label, temp_icon, LV_ALIGN_OUT_RIGHT_MID, 10, 0);

// 创建湿度图标（使用新的图片资源）
lv_obj_t *humidity_icon = lv_img_create(env_area);
lv_img_set_src(humidity_icon, &humi);
lv_obj_set_size(humidity_icon, 56, 56);  // 缩放到合适尺寸
lv_obj_align(humidity_icon, LV_ALIGN_LEFT_MID, 180, 0);

// 外部湿度数值标签（位于图标右侧）
humidity_value_label = lv_label_create(env_area);
lv_obj_set_style_text_font(humidity_value_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
lv_obj_set_style_text_color(humidity_value_label, lv_color_hex(0xecf0f1), LV_PART_MAIN);
lv_label_set_text(humidity_value_label, "60%");  // 固定显示60%
lv_obj_align_to(humidity_value_label, humidity_icon, LV_ALIGN_OUT_RIGHT_MID, 10, 0);



// 创建日期标签（贴着右侧边缘对齐）
date_label = lv_label_create(env_area);
lv_obj_set_style_text_font(date_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
lv_obj_set_style_text_color(date_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
lv_label_set_text(date_label, "加载中...");  // 临时文本，立即会被更新
lv_obj_align(date_label, LV_ALIGN_TOP_RIGHT, -5, 10);  // 与天气页面一致，进一步贴近右侧

// 创建时间标签
time_label = lv_label_create(env_area);
lv_obj_set_style_text_font(time_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
lv_obj_set_style_text_color(time_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
lv_label_set_text(time_label, "加载中...");  // 临时文本，立即会被更新
lv_obj_align(time_label, LV_ALIGN_TOP_RIGHT, -5, 40);  // 与天气页面一致，使用相同的右对齐基准

// 温湿度标签保持未知状态，等待用户设置实际值
// 不再使用硬编码的默认值

// 立即更新一次时间，确保显示正确的系统时间
update_time_task(NULL);

    // 创建控制面板
    lv_obj_t *control_panel = lv_obj_create(home_screen_instance);
    lv_obj_set_size(control_panel, 984, 350);  // 适应1024宽度，留出左右边距
    lv_obj_align(control_panel, LV_ALIGN_BOTTOM_MID, 0, -15);
    lv_obj_set_style_bg_color(control_panel, lv_color_hex(0x34495e), LV_PART_MAIN);
    lv_obj_set_style_radius(control_panel, 10, LV_PART_MAIN);
    lv_obj_set_style_border_width(control_panel, 0, LV_PART_MAIN);
    lv_obj_set_style_shadow_width(control_panel, 0, LV_PART_MAIN);
    lv_obj_set_style_pad_all(control_panel, 15, LV_PART_MAIN);
    
    // 删除控制面板标题以简化界面
    
    // 创建左侧控制区域
    lv_obj_t *left_control = lv_obj_create(control_panel);
    lv_obj_set_size(left_control, 450, 280);
    lv_obj_align(left_control, LV_ALIGN_LEFT_MID, 10, -10);  // 向上移动
    lv_obj_set_style_bg_color(left_control, lv_color_hex(0x2c3e50), LV_PART_MAIN);
    lv_obj_set_style_radius(left_control, 8, LV_PART_MAIN);
    lv_obj_set_style_border_width(left_control, 0, LV_PART_MAIN);
    lv_obj_clear_flag(left_control, LV_OBJ_FLAG_SCROLLABLE);  // 禁用左侧控制区滚动
    
    // 创建右侧控制区域
    lv_obj_t *right_control = lv_obj_create(control_panel);
    lv_obj_set_size(right_control, 450, 280);
    lv_obj_align(right_control, LV_ALIGN_RIGHT_MID, -10, -10);  // 向上移动
    lv_obj_set_style_bg_color(right_control, lv_color_hex(0x2c3e50), LV_PART_MAIN);
    lv_obj_set_style_radius(right_control, 8, LV_PART_MAIN);
    lv_obj_set_style_border_width(right_control, 0, LV_PART_MAIN);
    lv_obj_clear_flag(right_control, LV_OBJ_FLAG_SCROLLABLE);  // 禁用右侧控制区滚动
    
    // 创建灯光1开关
    light1_switch = lv_switch_create(left_control);
    lv_obj_align(light1_switch, LV_ALIGN_TOP_LEFT, 20, 20);
    lv_obj_add_event_cb(light1_switch, light_switch_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
    if(global_light1_state) {
        lv_obj_add_state(light1_switch, LV_STATE_CHECKED);
    } else {
        lv_obj_clear_state(light1_switch, LV_STATE_CHECKED);
    }

    // 创建灯光1标签
    light1_label = lv_label_create(left_control);
    lv_obj_set_style_text_font(light1_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(light1_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(light1_label, global_light1_state ? "灯光1: 开" : "灯光1: 关");
    lv_obj_align_to(light1_label, light1_switch, LV_ALIGN_OUT_RIGHT_MID, 10, 0);

    // 创建灯光2开关
    light2_switch = lv_switch_create(left_control);
    lv_obj_align(light2_switch, LV_ALIGN_TOP_LEFT, 20, 60);
    lv_obj_add_event_cb(light2_switch, light_switch_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
    if(global_light2_state) {
        lv_obj_add_state(light2_switch, LV_STATE_CHECKED);
    } else {
        lv_obj_clear_state(light2_switch, LV_STATE_CHECKED);
    }

    // 创建灯光2标签
    light2_label = lv_label_create(left_control);
    lv_obj_set_style_text_font(light2_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(light2_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(light2_label, global_light2_state ? "灯光2: 开" : "灯光2: 关");
    lv_obj_align_to(light2_label, light2_switch, LV_ALIGN_OUT_RIGHT_MID, 10, 0);

    // 创建灯光3开关
    light3_switch = lv_switch_create(left_control);
    lv_obj_align(light3_switch, LV_ALIGN_TOP_LEFT, 20, 100);
    lv_obj_add_event_cb(light3_switch, light_switch_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
    if(global_light3_state) {
        lv_obj_add_state(light3_switch, LV_STATE_CHECKED);
    } else {
        lv_obj_clear_state(light3_switch, LV_STATE_CHECKED);
    }

    // 创建灯光3标签
    light3_label = lv_label_create(left_control);
    lv_obj_set_style_text_font(light3_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(light3_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(light3_label, global_light3_state ? "灯光3: 开" : "灯光3: 关");
    lv_obj_align_to(light3_label, light3_switch, LV_ALIGN_OUT_RIGHT_MID, 10, 0);

    // 创建灯光4开关
    light4_switch = lv_switch_create(left_control);
    lv_obj_align(light4_switch, LV_ALIGN_TOP_LEFT, 20, 140);
    lv_obj_add_event_cb(light4_switch, light_switch_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
    if(global_light4_state) {
        lv_obj_add_state(light4_switch, LV_STATE_CHECKED);
    } else {
        lv_obj_clear_state(light4_switch, LV_STATE_CHECKED);
    }

    // 创建灯光4标签
    light4_label = lv_label_create(left_control);
    lv_obj_set_style_text_font(light4_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(light4_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(light4_label, global_light4_state ? "灯光4: 开" : "灯光4: 关");
    lv_obj_align_to(light4_label, light4_switch, LV_ALIGN_OUT_RIGHT_MID, 10, 0);
    
    // 删除空调开关以简化界面
    
    // 创建消息框（用于接收服务器消息）
    lv_obj_t *message_box = lv_obj_create(left_control);
    lv_obj_set_size(message_box, 420, 160);  // 缩小消息框高度避免与烟雾区域重合
    lv_obj_align(message_box, LV_ALIGN_TOP_MID, 0, 10);   // 向上移动一些
    lv_obj_set_style_bg_color(message_box, lv_color_hex(0x34495e), LV_PART_MAIN);
    lv_obj_set_style_radius(message_box, 8, LV_PART_MAIN);
    lv_obj_set_style_border_width(message_box, 1, LV_PART_MAIN);
    lv_obj_set_style_border_color(message_box, lv_color_hex(0x7f8c8d), LV_PART_MAIN);
    lv_obj_set_style_pad_all(message_box, 10, LV_PART_MAIN);
    lv_obj_clear_flag(message_box, LV_OBJ_FLAG_SCROLLABLE);  // 禁用消息框滚动
    
    // 消息标题
    lv_obj_t *message_title = lv_label_create(message_box);
    lv_obj_set_style_text_font(message_title, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(message_title, lv_color_hex(0x3498db), LV_PART_MAIN);
    lv_label_set_text(message_title, "系统消息");
    lv_obj_align(message_title, LV_ALIGN_TOP_LEFT, 0, 0);
    
    // 消息内容
    message_content = lv_label_create(message_box);
    lv_obj_set_style_text_font(message_content, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(message_content, lv_color_hex(0xecf0f1), LV_PART_MAIN);
    lv_label_set_text(message_content, "等待服务器消息...");
    lv_obj_align(message_content, LV_ALIGN_TOP_LEFT, 0, 30);
    lv_label_set_long_mode(message_content, LV_LABEL_LONG_WRAP);  // 自动换行
    lv_obj_set_size(message_content, 380, 100);  // 调整高度适应缩小的消息框
    
    // 创建烟雾浓度显示（位于left_control容器底部）
    lv_obj_t *smoke_icon = lv_label_create(left_control);
    lv_obj_set_style_text_font(smoke_icon, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(smoke_icon, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(smoke_icon, "烟雾:");
    lv_obj_align(smoke_icon, LV_ALIGN_BOTTOM_LEFT, 10, -20);  // 与进度条对齐
    
    // 烟雾浓度进度条（位于left_control容器底部）
    smoke_bar = lv_bar_create(left_control);
    lv_obj_set_size(smoke_bar, 280, 20);  // 适合left_control宽度
    lv_obj_align(smoke_bar, LV_ALIGN_BOTTOM_LEFT, 60, -20); // 位于left_control底部
    lv_bar_set_range(smoke_bar, 0, 100);
    lv_bar_set_value(smoke_bar, global_smoke_density, LV_ANIM_OFF);
    
    // 设置进度条样式 - 根据浓度显示不同颜色
    lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0x34495e), LV_PART_MAIN);
    if(global_smoke_density <= 30) {
        // 低浓度：绿色
        lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0x27ae60), LV_PART_INDICATOR);
    } else if(global_smoke_density <= 60) {
        // 中浓度：橙色
        lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0xf39c12), LV_PART_INDICATOR);
    } else {
        // 高浓度：红色
        lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0xe74c3c), LV_PART_INDICATOR);
    }
    
    // 烟雾浓度数值和状态标签（位于left_control容器底部）
    smoke_label = lv_label_create(left_control);
    lv_obj_set_style_text_font(smoke_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    char smoke_status_buf[64];
    char status_text[16];
    if(global_smoke_density <= 30) {
        lv_obj_set_style_text_color(smoke_label, lv_color_hex(0x27ae60), LV_PART_MAIN);
        strcpy(status_text, "良好");
    } else if(global_smoke_density <= 60) {
        lv_obj_set_style_text_color(smoke_label, lv_color_hex(0xf39c12), LV_PART_MAIN);
        strcpy(status_text, "注意");
    } else {
        lv_obj_set_style_text_color(smoke_label, lv_color_hex(0xe74c3c), LV_PART_MAIN);
        strcpy(status_text, "危险");
    }
    snprintf(smoke_status_buf, sizeof(smoke_status_buf), "%d%% %s", global_smoke_density, status_text);
    lv_label_set_text(smoke_label, smoke_status_buf);
    lv_obj_align(smoke_label, LV_ALIGN_BOTTOM_RIGHT, -10, -20);  // 与进度条对齐
    
    // 同步LED硬件状态与保存的状态
    led_set_state(LED1_GPIO, global_light1_state);
    led_set_state(LED2_GPIO, global_light2_state);
    led_set_state(LED3_GPIO, global_light3_state);
    led_set_state(LED4_GPIO, global_light4_state);

    // 同步到灯光控制界面的状态
    set_light_state(0, global_light1_state);
    set_light_state(1, global_light2_state);
    set_light_state(2, global_light3_state);
    set_light_state(3, global_light4_state);
    
    // 创建窗帘动图显示区域
    curtain_image = lv_img_create(right_control);
    // 根据保存的状态显示对应图片
    if(global_curtain_position >= 50) {
        lv_img_set_src(curtain_image, &open_cur);
    } else {
        lv_img_set_src(curtain_image, &close_cur);
    }
    lv_obj_align(curtain_image, LV_ALIGN_TOP_MID, 0, 30);  // 距离顶部30像素
    
    // 创建窗帘标签 (位于图片下方)
    curtain_label = lv_label_create(right_control);
    lv_obj_set_style_text_font(curtain_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(curtain_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    // 显示保存的窗帘状态
    char curtain_buf[32];
    snprintf(curtain_buf, sizeof(curtain_buf), "窗帘: %d%%", global_curtain_position);
    lv_label_set_text(curtain_label, curtain_buf);
    lv_obj_align_to(curtain_label, curtain_image, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);  // 位于图片下方10像素
    
    // 创建窗帘滑块 (位于标签下方)
    curtain_slider = lv_slider_create(right_control);
    lv_obj_set_size(curtain_slider, 300, 30);
    lv_obj_align_to(curtain_slider, curtain_label, LV_ALIGN_OUT_BOTTOM_MID, 0, 15);  // 位于标签下方15像素
    lv_slider_set_range(curtain_slider, 0, 100);
    lv_slider_set_value(curtain_slider, global_curtain_position, LV_ANIM_OFF); // 恢复保存的状态
    
    // 自定义滑块样式，修复绿色印子问题
    lv_obj_set_style_bg_color(curtain_slider, lv_color_hex(0x2c3e50), LV_PART_MAIN); // 背景色
    lv_obj_set_style_bg_color(curtain_slider, lv_color_hex(0x3498db), LV_PART_INDICATOR); // 蓝色指示器
    lv_obj_set_style_bg_color(curtain_slider, lv_color_hex(0xecf0f1), LV_PART_KNOB); // 白色旋钮
    
    lv_obj_add_event_cb(curtain_slider, curtain_slider_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
    
    // 创建窗帘自动控制按钮 (位于滑块下方)
    curtain_auto_btn = lv_btn_create(right_control);
    lv_obj_set_size(curtain_auto_btn, 120, 35);
    lv_obj_align_to(curtain_auto_btn, curtain_slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 15); // 位于滑块下方15像素
    lv_obj_set_style_radius(curtain_auto_btn, 8, LV_PART_MAIN);
    lv_obj_set_style_bg_color(curtain_auto_btn, lv_color_hex(0x95a5a6), LV_PART_MAIN); // 初始灰色（关闭状态）
    lv_obj_add_event_cb(curtain_auto_btn, curtain_auto_btn_event_cb, LV_EVENT_CLICKED, NULL);
    
    // 创建Auto按钮标签
    lv_obj_t *auto_btn_label = lv_label_create(curtain_auto_btn);
    lv_obj_set_style_text_font(auto_btn_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(auto_btn_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(auto_btn_label, "Auto: OFF");
    lv_obj_center(auto_btn_label);
    
    // 创建菜单按钮
    menu_btn = lv_btn_create(home_screen_instance);
    lv_obj_set_size(menu_btn, 40, 40);  // 调整按钮尺寸以适应文字
    lv_obj_align(menu_btn, LV_ALIGN_LEFT_MID, 0, 0);  // 紧贴左侧中部
    lv_obj_set_style_bg_color(menu_btn, lv_color_hex(0x2c3e50), LV_PART_MAIN);  // 使用与背景协调的深色
    lv_obj_set_style_bg_opa(menu_btn, LV_OPA_70, LV_PART_MAIN);  // 设置透明度为70%
    lv_obj_set_style_bg_color(menu_btn, lv_color_hex(0x1a2530), LV_PART_MAIN | LV_STATE_PRESSED);  // 按下时颜色
    lv_obj_set_style_radius(menu_btn, 5, 0);  // 轻微圆角，更美观
    lv_obj_set_style_border_width(menu_btn, 1, 0);
    lv_obj_set_style_border_color(menu_btn, lv_color_hex(0x2980b9), 0);
    lv_obj_set_style_shadow_width(menu_btn, 0, 0);
    lv_obj_add_event_cb(menu_btn, menu_btn_click_cb, LV_EVENT_CLICKED, NULL);
    // 确保按钮可见且在最前面
    lv_obj_clear_flag(menu_btn, LV_OBJ_FLAG_HIDDEN);
    lv_obj_move_foreground(menu_btn);

    // 初始化菜单位置为屏幕左侧外部
    sidebar_x = -240;

    // 创建菜单按钮文字
    lv_obj_t *menu_label = lv_label_create(menu_btn);
    lv_label_set_text(menu_label, ">");
    lv_obj_set_style_text_font(menu_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(menu_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_obj_center(menu_label);

    // 创建右拉菜单
    create_sidebar_menu(home_screen_instance);

    // 首页创建完成后，做一次全屏无效化，触发完整重绘以降低残影
    lv_obj_invalidate(home_screen_instance);
    
    // 在所有UI对象创建完成后，才创建定时器，避免竞态条件
    // 创建定时器，每秒更新一次时间
    timer_update = lv_timer_create(update_time_task, 1000, NULL);
    
    // 启动ADC烟雾浓度监测
    start_adc_smoke_monitoring();
}

// 更新温度值（仅更新标签文本）
static void set_temperature_value(int celsius) {
    if(celsius == last_temperature_value) return;
    
    // 检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        return;
    }
    
    if(temperature_value_label && lv_obj_is_valid(temperature_value_label)) {
        char buf[16];
        snprintf(buf, sizeof(buf), "%d°C", celsius);
        lv_label_set_text(temperature_value_label, buf);
    }
    last_temperature_value = celsius;
}

// 更新湿度值（仅更新标签文本）
static void set_humidity_value(int percent) {
    if(percent == last_humidity_value) return;
    
    // 检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        return;
    }
    
    if(humidity_value_label && lv_obj_is_valid(humidity_value_label)) {
        char buf[16];
        snprintf(buf, sizeof(buf), "%d%%", percent);
        lv_label_set_text(humidity_value_label, buf);
    }
    last_humidity_value = percent;
}

// 清理智能家居界面资源
void cleanup_smart_home_ui(void) {
    // 注意：不调用led_cleanup()以保持LED的物理状态
    // LED状态由全局变量维护，界面重建时会恢复
    
    // 先清理组件
    cleanup_smart_home_ui_components();
    
    // 清理全局对象指针
    time_label = NULL;
    date_label = NULL;
    light1_switch = NULL;
    light2_switch = NULL;
    ac_switch = NULL;
    curtain_slider = NULL;
    curtain_label = NULL;
    curtain_image = NULL;
    curtain_auto_btn = NULL;
    temperature_value_label = NULL;
    humidity_value_label = NULL;
    smoke_bar = NULL;
    smoke_label = NULL;
    message_content = NULL;
    
    // 清理菜单相关对象
    sidebar_menu = NULL;
    home_item = NULL;
    weather_item = NULL;
    devices_item = NULL;
    music_item = NULL;
    settings_item = NULL;
    shutdown_item = NULL;
    sidebar_mask = NULL;
    menu_btn = NULL;
    
    // 重置菜单状态
    sidebar_open = false;
    sidebar_x = -240;
    
    // 标记屏幕无效但不手动删除，让LVGL自动处理
    home_screen_valid = false;
    home_screen_instance = NULL;
}

// 更新系统信息框内容
void update_system_message(const char *message) {
    if(message_content && lv_obj_is_valid(message_content)) {
        lv_label_set_text(message_content, message);
        // 确保消息框重绘
        lv_obj_invalidate(message_content);
        printf("系统消息更新: %s\n", message);
    }
}

// 程序完全退出时的清理函数（用于关机等场景）
void final_cleanup_smart_home_ui(void) {
    // 执行常规清理
    cleanup_smart_home_ui();
    
    // 停止ADC监测（仅在程序完全退出时）
    stop_adc_smoke_monitoring();
    
    printf("智能家居UI: 完全清理完成\n");
}

// 安全返回智能家居界面（用于返回按钮）
void return_to_smart_home_ui(void) {
    // 更新系统消息
    update_system_message("返回主界面");

    // 额外的安全措施：确保没有遗留的定时器
    // 额外的安全措施：确保没有遗留的定时器
    if(adc_timer) {
        lv_timer_del(adc_timer);
        adc_timer = NULL;
    }
    if(timer_update) {
        lv_timer_del(timer_update);
        timer_update = NULL;
    }
    if(curtain_anim_timer) {
        lv_timer_del(curtain_anim_timer);
        curtain_anim_timer = NULL;
    }
    if(curtain_auto_timer) {
        lv_timer_del(curtain_auto_timer);
        curtain_auto_timer = NULL;
    }
    
    // 强制执行LVGL的定时器清理，确保没有遗留的回调
    lv_timer_handler();
    
    // 额外延迟，确保所有定时器回调完成
    usleep(50000);  // 50ms延迟
    
    // 直接创建，不使用延迟机制
    create_smart_home_ui();

    // 灯光状态已在开机时恢复，此处无需再次恢复

    // 添加短暂延迟，让定时器有机会执行
    usleep(10000);  // 10ms延迟


}

// 同步空调电源状态
void sync_ac_power_state(bool new_state) {
    global_ac_power_state = new_state;
    
    // 立即保存用户设置，确保状态持久化
    save_user_settings();
    
    // 检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        return; // 首页无效时不更新UI
    }
    
    // 如果首页空调开关存在，更新其状态
    if(ac_switch && lv_obj_is_valid(ac_switch)) {
        if(new_state) {
            lv_obj_add_state(ac_switch, LV_STATE_CHECKED);
        } else {
            lv_obj_clear_state(ac_switch, LV_STATE_CHECKED);
        }
        
        // 更新标签文本
        if(ac_label && lv_obj_is_valid(ac_label)) {
            lv_label_set_text(ac_label, new_state ? "空调: 开" : "空调: 关");
        }
    }
}

// 实现灯光控制界面的同步函数
void sync_light_states_to_homepage(void) {
    // 从灯光控制页面同步所有LED的状态到首页
    bool led1_state = get_light_state(0);
    bool led2_state = get_light_state(1);
    bool led3_state = get_light_state(2);
    bool led4_state = get_light_state(3);

    // 更新首页的全局状态变量
    global_light1_state = led1_state;
    global_light2_state = led2_state;
    global_light3_state = led3_state;
    global_light4_state = led4_state;

    // 仅更新全局状态变量，不直接控制硬件
    // 硬件控制应该只在实际需要改变灯状态时进行

    // 更新首页UI控件状态
    if(light1_switch && lv_obj_is_valid(light1_switch)) {
        if(global_light1_state) {
            lv_obj_add_state(light1_switch, LV_STATE_CHECKED);
        } else {
            lv_obj_clear_state(light1_switch, LV_STATE_CHECKED);
        }
        if(light1_label && lv_obj_is_valid(light1_label)) {
            lv_label_set_text(light1_label, global_light1_state ? "灯光1: 开" : "灯光1: 关");
        }
    }

    if(light2_switch && lv_obj_is_valid(light2_switch)) {
        if(global_light2_state) {
            lv_obj_add_state(light2_switch, LV_STATE_CHECKED);
        } else {
            lv_obj_clear_state(light2_switch, LV_STATE_CHECKED);
        }
        if(light2_label && lv_obj_is_valid(light2_label)) {
            lv_label_set_text(light2_label, global_light2_state ? "灯光2: 开" : "灯光2: 关");
        }
    }

    if(light3_switch && lv_obj_is_valid(light3_switch)) {
        if(global_light3_state) {
            lv_obj_add_state(light3_switch, LV_STATE_CHECKED);
        } else {
            lv_obj_clear_state(light3_switch, LV_STATE_CHECKED);
        }
        if(light3_label && lv_obj_is_valid(light3_label)) {
            lv_label_set_text(light3_label, global_light3_state ? "灯光3: 开" : "灯光3: 关");
        }
    }

    if(light4_switch && lv_obj_is_valid(light4_switch)) {
        if(global_light4_state) {
            lv_obj_add_state(light4_switch, LV_STATE_CHECKED);
        } else {
            lv_obj_clear_state(light4_switch, LV_STATE_CHECKED);
        }
        if(light4_label && lv_obj_is_valid(light4_label)) {
            lv_label_set_text(light4_label, global_light4_state ? "灯光4: 开" : "灯光4: 关");
        }
    }
}

void sync_light_states_from_homepage(void) {
    // 从首页的全局状态变量同步到灯光控制界面
    set_light_state(0, global_light1_state);
    set_light_state(1, global_light2_state);
    // 同步灯3和灯4的状态（从首页全局变量获取）
    set_light_state(2, global_light3_state);
    set_light_state(3, global_light4_state);
}

// 设置烟雾浓度
void set_smoke_density(int density) {
    // 限制范围在0-100之间
    if(density < 0) density = 0;
    if(density > 100) density = 100;
    
    global_smoke_density = density;
    
    // 检查首页是否有效
    if(!home_screen_valid || !home_screen_instance || !lv_obj_is_valid(home_screen_instance)) {
        return; // 首页无效时不更新UI
    }
    
    // 更新进度条
    if(smoke_bar != NULL && lv_obj_is_valid(smoke_bar)) {
        lv_bar_set_value(smoke_bar, density, LV_ANIM_ON);
        
        // 根据浓度更新进度条颜色
        if(density <= 30) {
            // 低浓度：绿色
            lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0x27ae60), LV_PART_INDICATOR);
        } else if(density <= 60) {
            // 中浓度：橙色
            lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0xf39c12), LV_PART_INDICATOR);
        } else {
            // 高浓度：红色
            lv_obj_set_style_bg_color(smoke_bar, lv_color_hex(0xe74c3c), LV_PART_INDICATOR);
        }
    }
    
    // 更新数值和状态标签（合并显示）
    if(smoke_label != NULL && lv_obj_is_valid(smoke_label)) {
        char smoke_status_buf[64];
        char status_text[16];
        if(density <= 30) {
            lv_obj_set_style_text_color(smoke_label, lv_color_hex(0x27ae60), LV_PART_MAIN);
            strcpy(status_text, "良好");
        } else if(density <= 60) {
            lv_obj_set_style_text_color(smoke_label, lv_color_hex(0xf39c12), LV_PART_MAIN);
            strcpy(status_text, "注意");
        } else {
            lv_obj_set_style_text_color(smoke_label, lv_color_hex(0xe74c3c), LV_PART_MAIN);
            strcpy(status_text, "危险");
        }
        snprintf(smoke_status_buf, sizeof(smoke_status_buf), "%d%% %s", density, status_text);
        lv_label_set_text(smoke_label, smoke_status_buf);
    }
    
    // 自动窗帘控制逻辑
    if(global_curtain_auto && curtain_slider != NULL && lv_obj_is_valid(curtain_slider) && 
       home_screen_valid && home_screen_instance && lv_obj_is_valid(home_screen_instance)) {
        int target_position;
        
        // 根据烟雾浓度计算窗帘开启程度
        if(density <= 20) {
            target_position = 100; // 低浓度：完全打开通风
        } else if(density <= 40) {
            target_position = 80;  // 轻度污染：大部分打开
        } else if(density <= 60) {
            target_position = 50;  // 中度污染：半开
        } else if(density <= 80) {
            target_position = 20;  // 重度污染：小开口
        } else {
            target_position = 0;   // 极重污染：完全关闭
        }
        
        // 调试输出，帮助理解窗帘控制逻辑
        printf("烟雾浓度: %d%%, 当前窗帘位置: %d%%, 目标位置: %d%%\n", 
               density, global_curtain_position, target_position);
        
        // 特殊控制逻辑：在烟雾浓度处于注意及以上级别时（中度污染及以上，即>40%）
        // 如果当前位置小于目标位置，则不移动（避免在高烟雾时意外打开窗帘）
        bool should_move = true;
        if(density > 40) {  // 中度污染及以上级别
            if(global_curtain_position < target_position) {
                should_move = false;
                printf("高烟雾浓度下阻止窗帘打开：当前%d%% < 目标%d%%，保持当前位置\n", 
                       global_curtain_position, target_position);
            }
        }
        
        // 只有在位置发生变化且允许移动时才启动渐进移动
        if(target_position != global_curtain_position && should_move) {
            curtain_target_position = target_position;
            
            // 停止现有的自动移动定时器（如果有的话）
            if(curtain_auto_timer != NULL) {
                lv_timer_del(curtain_auto_timer);
                curtain_auto_timer = NULL;
            }
            
            // 根据距离调整移动步长，距离越远步长越大
            int distance = abs(target_position - global_curtain_position);
            if(distance > 50) {
                curtain_move_step = 3;  // 大距离快速移动
            } else if(distance > 20) {
                curtain_move_step = 2;  // 中距离中速移动
            } else {
                curtain_move_step = 1;  // 小距离慢速移动
            }
            
            // 创建渐进移动定时器，每50ms移动一步
            curtain_auto_timer = lv_timer_create(curtain_auto_move_timer_cb, 50, NULL);
            

        }
    }
}

// 获取烟雾浓度
int get_smoke_density(void) {
    return global_smoke_density;
}

// ADC初始化函数
static int adc_init(void) {
    adc_fd = open(adc_device_path, O_RDONLY);
    if(adc_fd < 0) {
        return -1;
    }
    return 0;
}

// ADC清理函数
static void adc_cleanup(void) {
    if(adc_fd >= 0) {
        close(adc_fd);
        adc_fd = -1;
    }
}

// 读取ADC原始值
static int read_adc_raw_value(void) {
    if(adc_fd < 0) {
        return -1;  // ADC未初始化
    }
    
    char buf[64] = {0};
    
    // 重置文件指针到开头
    lseek(adc_fd, 0, SEEK_SET);
    
    // 读取ADC值
    int res = read(adc_fd, buf, sizeof(buf) - 1);
    if(res <= 0) {
        return -1;
    }
    
    // 确保字符串以null结尾
    buf[res] = '\0';
    
    // 转换为整数
    int adc_value = atoi(buf);
    
    return adc_value;
}

// 将ADC值转换为烟雾浓度百分比
static int convert_adc_to_smoke_density(int adc_value) {
    // 确保ADC值在有效范围内
    if(adc_value < adc_min_value) {
        return 0;  // 低于最小值时认为无烟雾
    }
    
    if(adc_value > adc_max_value) {
        return 100; // 超过最大值时认为浓度最高
    }
    
    // 使用线性映射：将ADC值范围[10, 1024]映射到烟雾浓度[0, 100]
    // 公式：density = (adc_value - min) * 100 / (max - min)
    int adc_range = adc_max_value - adc_min_value;  // 1024 - 10 = 1014
    int density = ((adc_value - adc_min_value) * 100) / adc_range;
    
    // 确保结果在0-100范围内（双重保险）
    if(density < 0) density = 0;
    if(density > 100) density = 100;
    
    return density;
}

// ADC定时器回调函数
static void adc_timer_cb(lv_timer_t *timer) {
    static int error_count = 0;
    
    // 额外的安全检查：确保timer参数有效
    if(!timer) {
        return;
    }
    
    // 首先检查首页是否有效，如果无效则只更新数据不更新UI
    bool ui_update_allowed = (home_screen_valid && home_screen_instance && lv_obj_is_valid(home_screen_instance));
    
    // 读取ADC原始值
    int adc_value = read_adc_raw_value();
    
    if(adc_value < 0) {
        error_count++;
        if(error_count >= 10) {
            if(adc_timer) {
                lv_timer_del(adc_timer);
                adc_timer = NULL;
            }
        }
        return;
    }
    
    // 重置错误计数
    error_count = 0;
    
    // 转换为烟雾浓度
    int smoke_density = convert_adc_to_smoke_density(adc_value);
    
    // 总是更新全局烟雾浓度数据，确保烟雾监控系统能获取到最新值
    global_smoke_density = smoke_density;
    
    // 只有在首页时才更新UI显示
    if (ui_update_allowed) {
        set_smoke_density(smoke_density);
    }
}

// 启动ADC烟雾浓度监测
static int start_adc_smoke_monitoring(void) {
    // 如果ADC定时器已经存在，先停止
    if(adc_timer) {
        lv_timer_del(adc_timer);
        adc_timer = NULL;
        adc_cleanup();
    }
    
    // 初始化ADC
    if(adc_init() != 0) {
        return -1;
    }
    
    // 创建定时器，每2秒读取一次ADC值
    adc_timer = lv_timer_create(adc_timer_cb, 2000, NULL);
    if(adc_timer == NULL) {
        adc_cleanup();
        return -1;
    }
    
    return 0;
}

// 停止ADC烟雾浓度监测
static void stop_adc_smoke_monitoring(void) {
    if(adc_timer) {
        lv_timer_del(adc_timer);
        adc_timer = NULL;
    }
    adc_cleanup();
}

// 创建智能家居界面
void create_smart_home_ui(void) {
    create_smart_home_ui_impl();
}

/*====================
 * MQTT云平台集成功能实现
 *==================*/

// 云同步定时器回调函数
static void cloud_sync_timer_cb(lv_timer_t *timer) {
    if (current_cloud_status == MQTT_CONNECTED) {
        // 定时同步触发 - 开始上传设备数据
        upload_all_device_data();
    } else {
        // 定时同步跳过 - MQTT未连接
    }
}

// 初始化MQTT云平台集成
void init_mqtt_cloud_integration(void) {
    // 初始化MQTT云平台集成
    
    
    // 显示当前所有灯光状态
    test_light_states();
    
    // 初始化MQTT模块
    mqtt_cloud_init();
    
    // 设置回调函数
    mqtt_cloud_set_status_callback(handle_mqtt_status_change);
    mqtt_cloud_set_message_callback(handle_mqtt_command);
    mqtt_cloud_set_light_control_callback(cloud_light_control_callback);  // 设置灯光控制回调
    mqtt_cloud_set_ac_control_callback(cloud_ac_control_callback);        // 设置空调控制回调
    mqtt_cloud_set_music_control_callback(cloud_music_control_callback);  // 设置音乐控制回调
    
    // 连接到云平台
    if (mqtt_cloud_connect() == 0) {
        update_system_message("正在连接云平台...");
    } else {
        update_system_message("云平台连接失败");
    }
}

// 上传所有设备数据到云平台
void upload_all_device_data(void) {
    if (current_cloud_status != MQTT_CONNECTED) {
        // 数据上传跳过 - MQTT未连接
        return;
    }
    
    // 开始收集设备数据
    
    device_data_t *data = calloc(1, sizeof(device_data_t));
    if (!data) {
        printf("upload_all_device_data: 内存分配失败\n");
        return;
    }
    
    // 收集空调数据
    data->ac_power = global_ac_power_state;
    data->ac_temperature = get_ac_current_temp(); // 获取实际温度
    data->ac_mode = get_ac_current_mode(); // 获取实际模式
    data->ac_fan_speed = get_ac_current_fan_speed(); // 获取实际风速
    
    // 收集四个独立灯光数据（从灯光控制模块获取实际状态）
    data->light1_power = get_light_state(0);  // 客厅灯
    data->light2_power = get_light_state(1);  // 卧室灯
    data->light3_power = get_light_state(2);  // 厨房灯
    data->light4_power = get_light_state(3);  // 阳台灯
    
    // 收集LED数据（根据所有灯光状态确定LED总状态）
    data->led_power = (data->light1_power || data->light2_power || data->light3_power || data->light4_power);
    
    // 收集环境数据（使用固定的展示值）
    data->temperature = 25; // 固定温度值25°C
    data->humidity = 60;    // 固定湿度值60%
    data->smoke_density = global_smoke_density; // 烟雾浓度
    
    // 收集音乐播放器数据（从音乐播放器模块获取实际状态）
    data->music_playing = (music_get_state() == MUSIC_STATE_PLAYING);
    data->music_volume = music_get_volume();
    const char* current_song_name = music_get_current_song();
    if (current_song_name != NULL) {
        strncpy(data->current_song, current_song_name, sizeof(data->current_song) - 1);
        data->current_song[sizeof(data->current_song) - 1] = '\0'; // 确保字符串结尾
    } else {
        strcpy(data->current_song, "无播放");
    }
    
    // 收集呼叫触发器数据（从设备状态管理器获取当前状态）
    device_state_t current_device_state = get_current_device_states();
    printf("upload_all_device_data: 从设备状态管理器获取的爸爸呼叫状态: %s\n", current_device_state.dad_call_triggered ? "true" : "false");
    data->dad_call_trigger = current_device_state.dad_call_triggered;
    data->mom_call_trigger = current_device_state.mom_call_triggered;
    data->son_call_trigger = current_device_state.son_call_triggered;
    data->daughter_call_trigger = current_device_state.daughter_call_triggered;

    // 调试：打印当前获取到的呼叫状态
    printf("upload_all_device_data: 呼叫状态 - 爸爸:%s, 妈妈:%s, 儿子:%s, 女儿:%s\n",
           data->dad_call_trigger ? "true" : "false",
           data->mom_call_trigger ? "true" : "false", 
           data->son_call_trigger ? "true" : "false",
           data->daughter_call_trigger ? "true" : "false");
    
    // 发送数据到云平台
    if (mqtt_cloud_publish_device_data(data) == 0) {
        // 设备数据上传请求提交成功
    } else {
        // 设备数据上传请求提交失败
    }
    
    // 释放分配的内存
    free(data);
}

// 处理MQTT状态变化
void handle_mqtt_status_change(mqtt_status_t status) {
    current_cloud_status = status;
    
    switch (status) {
        case MQTT_DISCONNECTED:
            update_system_message("云平台已断开");
            printf("MQTT云平台连接已断开\n");
            break;
            
        case MQTT_CONNECTING:
            update_system_message("正在连接云平台...");
            // 正在连接MQTT云平台
            break;
            
        case MQTT_CONNECTED:
            update_system_message("云平台已连接");
            // MQTT云平台连接成功
            // 订阅命令主题
            mqtt_cloud_subscribe_commands();
            // 启动定时同步
            start_cloud_sync_timer();
            // 立即上传一次数据
            upload_all_device_data();
            break;
            
        case MQTT_CONNECTION_FAILED:
            update_system_message("云平台连接失败");
            // MQTT云平台连接失败
            break;
    }
}

// 处理云平台命令
void handle_mqtt_command(const char* topic, const char* message) {
    // 收到云平台命令
    // 开始解析并执行命令
    
    // 这里可以解析JSON命令并执行相应的设备控制
    // 例如解析空调控制命令、灯光控制命令等
    
    // 示例：简单的文本命令处理
    if (strstr(message, "\"ac_power\":true")) {
        sync_ac_power_state(true);
        update_system_message("收到云端命令：开启空调");
    } else if (strstr(message, "\"ac_power\":false")) {
        sync_ac_power_state(false);
        update_system_message("收到云端命令：关闭空调");
    } else if (strstr(message, "\"light1_power\":true")) {
        set_light_state(0, true);  // 客厅灯
        update_system_message("收到云端命令：开启客厅灯");
    } else if (strstr(message, "\"light1_power\":false")) {
        set_light_state(0, false); // 客厅灯
        update_system_message("收到云端命令：关闭客厅灯");
    } else if (strstr(message, "\"light2_power\":true")) {
        set_light_state(1, true);  // 卧室灯
        update_system_message("收到云端命令：开启卧室灯");
    } else if (strstr(message, "\"light2_power\":false")) {
        set_light_state(1, false); // 卧室灯
        update_system_message("收到云端命令：关闭卧室灯");
    } else if (strstr(message, "\"light3_power\":true")) {
        set_light_state(2, true);  // 厨房灯
        update_system_message("收到云端命令：开启厨房灯");
    } else if (strstr(message, "\"light3_power\":false")) {
        set_light_state(2, false); // 厨房灯
        update_system_message("收到云端命令：关闭厨房灯");
    } else if (strstr(message, "\"light4_power\":true")) {
        set_light_state(3, true);  // 阳台灯
        update_system_message("收到云端命令：开启阳台灯");
    } else if (strstr(message, "\"light4_power\":false")) {
        set_light_state(3, false); // 阳台灯
        update_system_message("收到云端命令：关闭阳台灯");
    }
    
    // 命令解析完成，上传最新设备状态
    
    // 命令执行后上传最新状态
    upload_all_device_data();
}

// 启动云同步定时器
void start_cloud_sync_timer(void) {
    if (cloud_sync_timer == NULL) {
        // 每3秒同步一次数据
        cloud_sync_timer = lv_timer_create(cloud_sync_timer_cb, 3000, NULL);
        // 云同步定时器已启动，每3秒同步一次
    }
}

// 停止云同步定时器
void stop_cloud_sync_timer(void) {
    if (cloud_sync_timer != NULL) {
        lv_timer_del(cloud_sync_timer);
        cloud_sync_timer = NULL;
        // 云同步定时器已停止
    }
}

// 删除冗余的灯光3和灯光4控制函数，统一使用set_light_state和get_light_state

// 测试和显示所有灯光状态
void test_light_states(void) {
    // 立即上传当前状态
    if (current_cloud_status == MQTT_CONNECTED) {
        upload_all_device_data();
    } else {
        // MQTT未连接，无法上传
    }
}

// 切换指定灯光状态用于测试
void toggle_light_for_test(int light_index) {
    if (light_index < 0 || light_index > 3) {
        printf("无效的灯光索引: %d (有效范围: 0-3)\n", light_index);
        return;
    }
    
    const char* light_names[] = {"客厅灯", "卧室灯", "厨房灯", "阳台灯"};
    bool current_state = get_light_state(light_index);
    bool new_state = !current_state;
    
    printf("切换%s: %s -> %s\n", light_names[light_index], 
           current_state ? "开启" : "关闭", new_state ? "开启" : "关闭");
    
    set_light_state(light_index, new_state);
    
    // 立即上传新状态
    if (current_cloud_status == MQTT_CONNECTED) {
        upload_all_device_data();
    }
}

// 云平台灯光控制回调函数
void cloud_light_control_callback(int light_index, bool state) {
    printf("云平台控制灯光: 灯%d -> %s\n", light_index, state ? "开启" : "关闭");
    
    // 验证灯光索引
    if (light_index < 1 || light_index > 4) {
        printf("无效的灯光索引: %d\n", light_index);
        return;
    }
    
    // 转换为数组索引（从0开始）
    int array_index = light_index - 1;
    
    // 控制硬件LED
    int gpio_pin = 0;
    switch (light_index) {
        case 1: gpio_pin = LED1_GPIO; break;  // 客厅灯
        case 2: gpio_pin = LED2_GPIO; break;  // 卧室灯
        case 3: gpio_pin = LED3_GPIO; break;  // 厨房灯
        case 4: gpio_pin = LED4_GPIO; break;  // 阳台灯
        default: return;
    }
    
    // 设置硬件LED状态
    if (led_set_state(gpio_pin, state) == 0) {
        printf("硬件LED控制成功: GPIO%d -> %s\n", gpio_pin, state ? "开启" : "关闭");
        
        // 更新全局LED状态
        set_global_led_state(array_index, state);
        
        // 更新灯光控制界面状态（如果界面已创建）
        set_light_state(array_index, state);
        
        // 同步到首页界面
        sync_light_states_to_homepage();
        
        // 保存用户设置
        save_user_settings();
        
        // 显示系统消息
        const char* light_names[] = {"客厅灯", "卧室灯", "厨房灯", "阳台灯"};
        char message[128];
        snprintf(message, sizeof(message), "云端控制: %s%s", 
                light_names[array_index], state ? "开启" : "关闭");
        update_system_message(message);
        
        printf("灯光状态已同步到界面和保存到设置\n");
    } else {
        printf("硬件LED控制失败: GPIO%d\n", gpio_pin);
        update_system_message("云端控制失败");
    }
}

// 云平台空调控制回调函数
void cloud_ac_control_callback(const char* action, int value) {
    printf("云平台控制空调: 动作=%s, 值=%d\n", action, value);
    
    if (strcmp(action, "power") == 0) {
        // 控制空调开关
        bool power_state = (value == 1);
        sync_ac_power_state(power_state);
        
        // 刷新空调界面UI（如果当前在空调界面）
        extern void refresh_ac_control_ui(void);
        refresh_ac_control_ui();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 空调%s", power_state ? "开启" : "关闭");
        update_system_message(message);

        printf("空调电源状态已设置为: %s\n", power_state ? "开启" : "关闭");
    }
    else if (strcmp(action, "temperature") == 0) {
        // 调节空调温度
        if (value >= 16 && value <= 30) {
            set_ac_temp_from_settings(value);
            
            // 刷新空调界面UI（如果当前在空调界面）
            extern void refresh_ac_control_ui(void);
            refresh_ac_control_ui();
            
            char message[64];
            snprintf(message, sizeof(message), "云端控制: 空调温度%d°C", value);
            update_system_message(message);

            printf("空调温度已设置为: %d°C\n", value);
        } else {
            printf("无效的空调温度值: %d\n", value);
            update_system_message("云端控制: 温度值无效");
        }
    }
    else if (strcmp(action, "mode") == 0) {
        // 切换空调模式
        if (value >= 0 && value <= 4) {
            set_ac_mode_from_settings(value);
            
            // 刷新空调界面UI（如果当前在空调界面）
            extern void refresh_ac_control_ui(void);
            refresh_ac_control_ui();
            
            const char* mode_names[] = {"制冷", "制热", "送风", "除湿", "自动"};
            char message[64];
            snprintf(message, sizeof(message), "云端控制: 空调%s模式", mode_names[value]);
            update_system_message(message);

            printf("空调模式已设置为: %d (%s)\n", value, mode_names[value]);
        } else {
            printf("无效的空调模式值: %d\n", value);
            update_system_message("云端控制: 模式值无效");
        }
    }
    else if (strcmp(action, "fan_speed") == 0) {
        // 调节空调风速
        if (value >= 0 && value <= 3) {
            restore_ac_fan_speed(value);
            
            // 刷新空调界面UI（如果当前在空调界面）
            extern void refresh_ac_control_ui(void);
            refresh_ac_control_ui();
            
            const char* fan_speed_names[] = {"自动", "低", "中", "高"};
            char message[64];
            snprintf(message, sizeof(message), "云端控制: 空调风速%s", fan_speed_names[value]);
            update_system_message(message);

            printf("空调风速已设置为: %d (%s)\n", value, fan_speed_names[value]);
        } else {
            printf("无效的空调风速值: %d\n", value);
            update_system_message("云端控制: 风速值无效");
        }
    }
    else {
        printf("未知的空调控制动作: %s\n", action);
        update_system_message("云端控制: 未知动作");
    }
    
    // 保存用户设置
    save_user_settings();
}

// 云平台音乐控制回调函数
void cloud_music_control_callback(const char* action, int value) {
    printf("云平台控制音乐播放器: 动作=%s, 值=%d\n", action, value);
    
    if (strcmp(action, "play") == 0) {
        // 播放音乐
        extern void music_play(void);
        music_play();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 音乐播放");
        update_system_message(message);

        printf("音乐已开始播放\n");
    }
    else if (strcmp(action, "pause") == 0) {
        // 暂停音乐
        extern void music_pause(void);
        music_pause();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 音乐暂停");
        update_system_message(message);

        printf("音乐已暂停\n");
    }
    else if (strcmp(action, "stop") == 0) {
        // 停止音乐
        extern void music_stop(void);
        music_stop();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 音乐停止");
        update_system_message(message);

        printf("音乐已停止\n");
    }
    else if (strcmp(action, "next") == 0) {
        // 下一首
        extern void music_next(void);
        music_next();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 下一首");
        update_system_message(message);

        printf("已切换到下一首\n");
    }
    else if (strcmp(action, "previous") == 0) {
        // 上一首
        extern void music_previous(void);
        music_previous();
        
        char message[64];
        snprintf(message, sizeof(message), "云端控制: 上一首");
        update_system_message(message);

        printf("已切换到上一首\n");
    }
    else if (strcmp(action, "volume") == 0) {
        // 调节音量
        if (value >= 0 && value <= 100) {
            extern void music_set_volume(int volume);
            music_set_volume(value);
            
            char message[64];
            snprintf(message, sizeof(message), "云端控制: 音量%d", value);
            update_system_message(message);

        printf("音量已设置为: %d\n", value);
        } else {
            printf("无效的音量值: %d\n", value);
            update_system_message("云端控制: 音量值无效");
        }
    }
    else if (strcmp(action, "song") == 0) {
        // 切换歌曲
        if (value >= 0 && value <= 10) { // 假设最多支持10首歌
            extern void music_set_current_song_index(int index);
            music_set_current_song_index(value);
            
            char message[64];
            snprintf(message, sizeof(message), "云端控制: 歌曲%d", value);
            update_system_message(message);

        printf("已切换到歌曲: %d\n", value);
        } else {
            printf("无效的歌曲索引: %d\n", value);
            update_system_message("云端控制: 歌曲索引无效");
        }
    }
    else {
        printf("未知的音乐控制动作: %s\n", action);
        update_system_message("云端控制: 未知动作");
    }
    
    // 刷新音乐播放器界面UI（如果当前在音乐播放器界面）
    extern void refresh_music_player_ui(void);
    refresh_music_player_ui();
    
    // 上传音乐播放器状态到云平台
    extern music_state_t music_get_state(void);
    extern int music_get_volume(void);
    extern const char* music_get_current_song(void);
    
    bool playing = (music_get_state() == MUSIC_STATE_PLAYING);
    int current_volume = music_get_volume();
    const char* current_song = music_get_current_song();
    
    extern int mqtt_upload_music_data(bool playing, int volume, const char* song);
    mqtt_upload_music_data(playing, current_volume, current_song ? current_song : "");
}



